Mitä eroa on 'git pull' ja 'git fetch' välillä?

1
2
Seuraava
Yksinkertaisesti sanottuna git-veto tekee git-haun, jota seuraa git-sulautuminen.
Voit tehdä git-haun milloin tahansa päivittääksesi etäseurannan haarat kohdassa refs / remotes /  /.
Tämä toimenpide ei koskaan muuta mitään omia paikallisia haaroja viitteiden / päätyjen alla, ja se on turvallista tehdä muuttamatta työkopiota. Olen jopa kuullut ihmisistä, jotka suorittavat git-hakuja säännöllisesti taustalla olevalla cron-työllä (vaikka en suosittelisi tekemään tätä).
Git pull on se, mitä tekisit tuodaksesi paikallisen haaran ajan tasalle etäversiollaan, samalla kun päivität muut etäseurannan haarasi.
Git-vedon Git-dokumentaatiosta:
Oletustilassa git-vedos on lyhennys git-haulle, jota seuraa git-yhdistäminen FETCH_HEAD.
|
Kun käytät pullia, Git yrittää tehdä työn automaattisesti puolestasi. Se on kontekstiherkkä, joten Git yhdistää kaikki vedetyt sitoumukset haaraan, jolla parhaillaan työskentelet. Pull yhdistää tehdyt tehtävät automaattisesti antamatta sinun tarkistaa niitä ensin. Jos et hallitse sivuliikkeitäsi tarkasti, saatat joutua usein konflikteihin.
Kun haet, Git kerää kohdekonttorista kaikki sitoumukset, joita ei ole nykyisessä haarassasi, ja tallentaa ne paikalliseen arkistoon. Se ei kuitenkaan yhdistä niitä nykyiseen haarasi. Tämä on erityisen hyödyllistä, jos sinun on pidettävä tietovarastosi ajan tasalla, mutta olet tekemässä jotain, joka saattaa rikkoutua, jos päivität tiedostosi.
Integroi sitoumukset päähaarallesi käyttämällä yhdistämistä.
|
On tärkeää verrata gitin suunnittelufilosofiaa perinteisemmän lähdekontrollityökalun, kuten SVN, filosofiaan.
Subversion suunniteltiin ja rakennettiin asiakas / palvelin-mallilla. On yksi arkisto, joka on palvelin, ja useat asiakkaat voivat hakea koodia palvelimelta, työskennellä sen kanssa ja sitoa sen sitten takaisin palvelimelle. Oletuksena on, että asiakas voi aina ottaa yhteyttä palvelimeen, kun sen on suoritettava toiminto.
Git on suunniteltu tukemaan hajautetumpaa mallia ilman keskitetyn arkiston tarvetta (vaikka voit varmasti käyttää sitä, jos haluat). Myös git on suunniteltu siten, että asiakkaan ja "palvelimen" ei tarvitse olla verkossa samanaikaisesti. Git on suunniteltu siten, että epäluotettavalla linkillä olevat ihmiset voivat vaihtaa koodia sähköpostitse. On mahdollista työskennellä täysin irrotettuna ja polttaa CD vaihtaaksesi koodia gitin kautta.
Tämän mallin tukemiseksi git ylläpitää paikallista arkistoa koodillasi ja myös ylimääräistä paikallista arkistoa, joka heijastaa etärekisterin tilaa. Pitämällä kopio etätietovarastosta paikallisesti, git voi selvittää tarvittavat muutokset silloinkin, kun etärekisteri ei ole tavoitettavissa. Myöhemmin, kun sinun on lähetettävä muutokset jollekin muulle, git voi siirtää ne muutosjoukkoina etätietovarastolle tiedetystä ajankohdasta.
git nouto on komento, joka sanoo "tuo paikallisen kopioni etätietovarastosta ajan tasalle".
git pull sanoo "tuo muutokset etätietovarastoon sinne, missä pidän omaa koodiani".
Normaalisti git -veto tekee tämän tekemällä git-haun tuodakseen etärekisterin paikallisen kopion ajan tasalle ja yhdistämällä muutokset omaan koodivarastoon ja mahdollisesti työkopioon.
Ota mukaan on pidettävä mielessä, että työasemallasi on usein vähintään kolme kopiota projektista. Yksi kopio on oma arkisto, jolla on oma sitoutumishistoriasi. Toinen kappale on työkopio, johon muokkaat ja rakennat. Kolmas kopio on paikallinen "välimuistissa oleva" kopio etätietovarastosta.
|
Tässä on Oliver Steelen kuva siitä, kuinka kaikki kaikki sopivat yhteen:
Jos kiinnostusta on riittävästi, voisin päivittää kuvan lisätäksesi git-kloonin ja git-yhdistämisen ...
|
Yksi git-haun käyttötapa on, että seuraava kertoo kaikki muutokset etähaarassa viimeisen vetosi jälkeen ... joten voit tarkistaa ennen varsinaisen vedon tekemistä, mikä voi muuttaa nykyisen haarasi ja työkopion tiedostoja.
git noutaa
git diff ... alkuperä
Katso diff-komennon kaksois- ja kolmoispisteiden syntaksit: https://git-scm.com/docs/git-diff
|
Minulle maksoi hieman ymmärtää, mikä oli ero, mutta tämä on yksinkertainen selitys. isäntä paikallishostollessasi on haara.
Kun kloonaat tietovaraston, haet koko arkiston paikalliselle isännälle. Tämä tarkoittaa, että tuolloin sinulla on alkuperä / pääosoitin HEAD ja päällikkö osoittavat samaan HEAD.
kun aloitat työskentelyn ja teet sitoutumisen, siirrät pääosoittimen kohtaan HEAD + tekemäsi tehtävät. Alkuperä- / pääosoitin osoittaa kuitenkin edelleen sitä, mitä se oli, kun kloonasit.
Joten ero on:
Jos haet git-haun, se vain hakee kaikki muutokset etätietovarastosta (GitHub) ja siirtää alkuperäisen / pääosoittimen kohtaan HEAD. Sillä välin paikallisen haaratoimistosi päällikkö näyttää jatkuvasti missä se on.
Jos teet git-vedon, se hakee periaatteessa (kuten aiemmin selitettiin) ja yhdistää kaikki uudet muutoksetpäähaara ja siirrä osoitin kohtaan HEAD.
|
Joskus visuaalinen esitys auttaa.
|
Lyhyesti
git-nouto on samanlainen kuin vetäminen, mutta ei sulautu. ts. se hakee etäpäivitykset (viitteet ja objektit), mutta paikallinen pysyy samana (eli alkuperä / pääosa päivittyy, mutta päällikkö pysyy samana).
git pull vetää alas kaukosäätimestä ja sulautuu välittömästi.
Lisää
git-klooni kloonaa repon.
git rebase tallentaa nykyisen haarasi sisältöä, joka ei ole ylävirran haarassa, väliaikaiselle alueelle. Haarasi on nyt sama kuin ennen muutosten aloittamista. Joten, git pull -rebase vetää etämuutokset alas, kelaa paikallisen haarasi taaksepäin, toistaa muutokset nykyisen haarasi yläosassa yksitellen, kunnes olet ajan tasalla.
Lisäksi git-haara -a näyttää sinulle tarkalleen, mitä kaikissa sivuliikkeissäsi tapahtuu - paikallisessa ja etäyhteydessä.
Tämä blogiviesti oli hyödyllinen:
Ero git-pullin, git-haun ja git-kloonin (ja git rebase) välillä - Mike Pearce
ja se kattaa git pull, git fetch, git klooni ja git rebase.
====
PÄIVITTÄÄ
Ajattelin päivittää tämän osoittamaan, miten käytät tätä käytännössä.
Päivitä paikallinen repo kaukosäätimestä (mutta älä yhdistä):
git noutaa
Päivitysten lataamisen jälkeen katsotaanpa erot:
git diff master-alkuperä / master
Jos olet tyytyväinen päivityksiin, yhdistä sitten:
git vetää
Huomautuksia:
Vaiheesta 2: Lisätietoja paikallisten ja kaukosäätimien välisistä eroista on ohjeaiheessa: Kuinka verrata paikallista git-haaraa sen etähaaraan?
Vaiheesta 3: On todennäköisesti tarkempaa (esim. Nopeasti muuttuvassa repossa) tehdä git-uudelleentallennusalku täällä. Katso @Justin Ohms kommentti toisessa vastauksessa.
Katso myös: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Hae toisesta arkistosta tai paikallisesta haarasta ja sulauta se
YHTEENVETO
git pull ...
KUVAUS
Suorittaa git-fetch annetuilla parametreilla ja kutsuu git-merge yhdistämään
haetut päät (t) nykyiseen haaraan. --Rebase-toiminnolla kutsuu git-rebase
git-sulautumisen sijaan.
Huomaa, että voit käyttää. (nykyinen hakemisto) vedettäväksi 
paikallisesta arkistosta - tämä on hyödyllistä, kun paikalliset haarat yhdistetään
nykyiseen haaraan.
Huomaa myös, että vaihtoehdot, jotka on tarkoitettu itse git-pullille ja taustalla olevalle git-sulautumiselle
on annettava ennen git-fetchille tarkoitettuja vaihtoehtoja.
Voit vetää, jos haluat, että historiat yhdistetään, haet, jos haluat vain koodeksin, koska joku on merkinnyt joitain artikkeleita täältä.
|
Voit noutaa etätietovarastosta, nähdä erot ja vetää tai yhdistää.
Tämä on esimerkki etärekisteristä nimeltä origo ja haarasta nimeltä master, joka seuraa etäkonttorin alkuperää / masteria:
git kassan päällikkö
git noutaa
git diff alkuperä / master
git rebase -aloitusmestari
|
Lyhyt ja helppo vastaus on, että git pull on yksinkertaisesti git-nouto, jota seuraa git-yhdistäminen.
On erittäin tärkeää huomata, että git-vetovoima sulautuu automaattisesti, pidät siitä tai et. Tämä voi tietysti johtaa yhdistymiskonflikteihin. Oletetaan, että kaukosäädin on alkuperä ja haara on isäntä. Jos hankit diff-alkuperän / päällikön ennen vetämistä, sinulla pitäisi olla jonkinlainen käsitys mahdollisista yhdistymiskonflikteista ja voit valmistautua paikalliseen haaratoimistoon vastaavasti.
Joissakin työnkuluissa on vetämisen ja työntämisen lisäksi git rebase, kuten tämä, jonka muotoilen linkitetystä artikkelista:
git pull -aloitusmestari
git kassa foo-haara
git uudelleentallennusmestari
git push alkuperä foo-haara
Jos löydät itsesi tällaiseen tilanteeseen, saatat joutua houkutukseksi vetämään --rebase. Ellet todella, todella tiedä, mitä teet, suosittelen sitä. Tämä varoitus on git-pull-version man-sivulta, versio 2.3.5:
Tämä on mahdollisesti vaarallinen toimintatapa. Se kirjoittaa uudestaan
historia, mikä ei ole mitään hyvää, kun julkaisit kyseisen historian
jo. Älä käytä tätä vaihtoehtoa, ellet ole lukenut git-rebase-ohjelmaa (1)
huolellisesti.
|
OK, tässä on joitain tietoja git-pullista ja git-hausta, joten voit ymmärtää todelliset erot ... muutamalla yksinkertaisella sanalla, nouto saa uusimmat tiedot, mutta ei koodimuutoksia eikä aio sotkea nykyisen paikallisen haarakoodisi kanssa , mutta vedä saadaksesi koodimuutokset ja yhdistä se paikalliseen haaratoimistoon. Lue lisää saadaksesi lisätietoja kustakin:
git noutaa
Se lataa kaikki viitteet ja objektit sekä kaikki uudet haarat paikalliseen arkistoon ...
Hae haarat ja / tai tunnisteet (yhdessä "viitteet") yhdestä tai useammasta
muut arkistot sekä niiden täydentämiseen tarvittavat esineet
historiaa. Etäseurannan haarat päivitetään (katso kuvaus
alla olevista tavoista hallita tätä käyttäytymistä).
Oletuksena kaikki tunnisteet, jotka osoittavat haettaviin historiaihin, ovat
myös haettu; seurauksena on noutaa tageja, jotka osoittavat haaroihin
olet kiinnostunut. Tätä oletuskäyttäytymistä voidaan muuttaa käyttämällä
--tags tai --no-tags vaihtoehtoja tai määrittämällä
remote..tagOpt. Käyttämällä refspeciä, joka noutaa tunnisteet nimenomaisesti,
voit hakea tunnisteita, jotka eivät osoita sinua kiinnostavia haaroja
samoin.
git-nouto voi noutaajoko yksittäinen nimetty arkisto tai URL, tai
useista arkistoista kerralla, jos annetaan ja on
kaukosäätimet. merkintä määritystiedostoon. (Katso git-config1).
Kun kaukosäädintä ei ole määritetty, lähtökaukosäädin on oletusarvoisesti
käytetään, ellei virralle ole määritetty ylävirran haaraa
haara.
Haettujen viitteiden nimet yhdessä objektien nimien kanssa
ne osoittavat, kirjoitetaan osoitteeseen .git / FETCH_HEAD. Nämä tiedot voivat olla
skriptit tai muut git-komennot, kuten git-pull.
git vetää
Se soveltaa muutoksia kaukosäätimestä nykyiseen haaraan paikallisessa ...
Sisältää muutokset etätietovarastosta nykyiseen haaraan.
Oletustilassa git-vedos on lyhennys git-haulle, jota seuraa
git-yhdistäminen FETCH_HEAD.
Tarkemmin sanottuna git pull suorittaa git-haun annetuilla parametreilla ja
kutsujen git sulautuminen yhdistää haetut haarapäät nykyiseen
haara. --Rebase-ohjelmalla se suorittaa git-uudelleentallennuksen git-yhdistämisen sijaan.
pitäisi olla etätietovaraston nimi, jolle se on siirretty
git-nouto 1. osaa nimetä mielivaltaisen etäreffin (esimerkiksi
tunnisteen nimi) tai jopa kokoelma viitteitä vastaavilla
etäseurannan haarat (esim. refs / heads /: refs / remotes / origin /),
mutta yleensä se on etätietovaraston haaran nimi.
Oletusarvot kohteelle ja luetaan
"etä" - ja "yhdistää" -asetukset nykyiselle haaralle
git-branch - raita.
Luon myös alla olevan visuaalisen kuvan osoittamaan, kuinka git-nouto ja git-veto toimivat yhdessä ...
|
Tämä interaktiivinen graafinen esitys on erittäin hyödyllinen gitin ymmärtämisessä: http://ndpsoftware.com/git-cheatsheet.html
git fetch vain "lataa" muutokset kaukosäätimestä paikalliseen arkistoon. git pull lataa muutokset ja yhdistää ne nykyiseen haaraan. "Oletustilassa git-vedos on lyhennys git-haulle, jota seuraa git-yhdistäminen FETCH_HEAD."
|
Bonus:
Puhuessani vedosta ja noutamisesta yllä olevissa vastauksissa haluaisin jakaa mielenkiintoisen temppun,
git pull --rebase
Tämä yllä oleva komento on hyödyllisin komento elämässäni, joka säästää paljon aikaa.
Ennen kuin työnnät uuden sitoutumisen palvelimelle, kokeile tätä komentoa, ja se synkronoi automaattisesti viimeisimmät palvelimen muutokset (nouto + yhdistäminen) ja sijoittaa sitoumuksesi ylhäältä git-lokiin. Ei tarvitse huolehtia manuaalisesta vetämisestä / yhdistämisestä.
Lisätietoja on osoitteessa http://gitolite.com/git-pull--rebase
|
Haluan saada jonkinlaisen visuaalisen kuvan tilanteesta näiden asioiden ymmärtämiseksi. Ehkä muutkin kehittäjät haluavat nähdä sen, joten tässä on lisäykseni. En ole täysin varma, että kaikki on oikein, joten kommentoi, jos löydät virheitä.
PAIKALLINEN JÄRJESTELMÄ
. ==================================================== ===
=================. ================= =================== =============
KAUKOSÄILIÖ. KAUKOSÄILIÖ PAIKALLINEN VARASTO TYÖKOPIO
(ALKUPERÄ). (Välimuisti)
esimerkiksi,      . peili
github-repo. . kaukosäädin
Voi myös olla       .
useita repoja.
.
.
FETCH * ------------------> *
Kauko-ohjaimen paikallinen välimuisti päivitetään alkuperällä (tai useilla
ulkoiset lähteet, eli gitin hajautettu luonne)
.
PULL * ------------------------------------------------ --------> *
muutokset yhdistetään suoraan paikalliseen kopioosi. kun konflikteja tapahtuu,
sinua pyydetään tekemään päätöksiä.
.
TEHDÄ     ​​       . * <--------------- *
Kun tulet esimerkiksi kumouksesta, saatat ajatella sitoutumista
päivittää alkuperän. Gitissä sitoutuminen tehdään vain paikalliselle repoosi.
.
PUSH * <--------------------------------------- *
Synkronoi muutokset takaisin alkuperään.
Joitakin merkittäviä etuja kaukosäätimen peilin hakemisesta ovat:
Suorituskyky (selaa kaikkia sitoumuksia ja viestejä yrittämättä puristaa sitä verkon läpi)
Palaute paikallisen ostotilasi tilasta (käytän esimerkiksi Atlassian's SourceTree -ohjelmaa, joka antaa minulle lampun, joka osoittaa, sitoutunko eteenpäin vai taaksepäin alkuperään verrattuna. Nämä tiedot voidaan päivittää GIT FETCHilla).
|
Olen myös taistellut tämän kanssa. Itse asiassa sain tänne Google-haun täsmälleen samasta kysymyksestä. Kaikkien näiden vastausten lukeminen maalasi lopulta kuvan päähäni ja päätin yrittää saada tämän alas tarkastelemalla kahden arkiston tilaa ja yhden hiekkalaatikon tilaa ja ajan mittaan suoritettuja toimintoja katsellessani niiden versiota. Joten tässä keksin. Korjaa minut, jos olen sekaisin missä tahansa.
Kolme repoa haulla:
--------------------- ----------------------- ------ -----------------
- Kauko-repo - - Etäkäyttöinen repo - - Etärepo -
- - - työnnetään - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Paikallinen repo - - Paikallinen repo - - Paikallinen repo -
- vedä - - - - hae -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Paikallinen hiekkalaatikko - - Paikallinen hiekkalaatikko - - Paikallinen hiekkalaatikko -
- Kassalle - - uusi työ tehty - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
Kolme repoa vetämällä
--------------------- ----------------------- ------ -----------------
- Kauko-repo - - Etäkäyttöinen repo - - Etärepo -
- - - työnnetään - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Paikallinen repo - - Paikallinen repo - - Paikallinen repo -
- vedä - - - - vedä -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Paikallinen hiekkalaatikko - - Paikallinen hiekkalaatikko - - Paikallinen hiekkalaatikko -
- Kassalle - - uusi työ tehty - - yhdistetty R02: een -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Tämä auttoi minua ymmärtämään, miksi hakeminen on melko tärkeää.
|
GIT-haun ja GIT-vedon välinen ero voidaan selittää seuraavalla skenaarialla:
(Pidä mielessä, että kuvat puhuvat enemmän kuin sanat!, Olen toimittanut kuvallisen esityksen.)
Otetaan esimerkki siitä, että työskentelet projektissa tiimisi jäsenten kanssa. Joten projektissa on yksi pääosasto, ja kaikkien osallistujien on haaroitettava se omaan paikalliseen arkistoonsa ja työskenneltävä tämän paikallisen haaran parissa modifioimalla / lisäämällä moduuleja ja työntämällä sitten takaisin päähaaraan.
Niin,
Kahden haaran alkutila, kun haaroitit pääprojektin paikalliselle arkistollesi, on näin - (A, B ja C ovat moduuleita, jotka on jo saatu valmiiksi projektissa)
Nyt olet aloittanut uuden moduulin (oletetaan, että D) valmistamisen ja kun olet suorittanut D-moduulin, haluat työntää sen päähaaraan. Mutta sillä välin tapahtuu, että yksi joukkuetovereistasi on kehittänyt uuden moduulin E, F ja muunnettu C.
Joten nyt on tapahtunut, että paikallinen tietovarastosi puuttuu projektin alkuperäisestä etenemisestä ja siten muutosten työntäminen päähaaraan voi johtaa konflikteihin ja saattaa aiheuttaa moduulin D toimintahäiriön.
Tällaisten ongelmien välttämiseksi ja projektin alkuperäisen edistymisen rinnalla työskentelemiseksi on kaksi tapaa:
1. Git Fetch - Tämä lataa kaikki muutokset, jotka on tehty lähtö- / päähaarakohtaiseen projektiin ja joita ei ole paikallisessa haarakonttorissasi. Ja odottaa, että Git Merge -komento soveltaa arkistoon tai haaraan haettuja muutoksia.
Joten nyt voit seurata tiedostoja huolellisesti ennen yhdistämistä arkistoon. Ja voit myös muokata D: tä tarvittaessa muokatun C: n vuoksi.
2. Git Pull - Tämä päivittää paikallisen haarasi alkuperällä / päähaaralla, eli itse asiassa se, mitä se tekee, on Git Fetch- ja Git-yhdistelmien yhdistelmä peräkkäin.
Mutta tämä voi aiheuttaa ristiriitoja, joten on suositeltavaa käyttää Git Pullia puhtaalla kopiolla.
|
Sanomme yksinkertaisesti:
git pull == git-nouto + git-yhdistäminen
Jos suoritat git pull -toiminnon, tietoja ei tarvitse yhdistää paikallisiin. Jos suoritat git-haun, se tarkoittaa, että sinun on suoritettava git merge saadaksesi uusimman koodin paikalliseen koneeseesi. Muuten paikallista konekoodia ei muuteta ilman yhdistämistä.
Joten Git Guissa, kun haet, sinun on yhdistettävä tiedot. Nouto itse ei tee koodimuutoksia paikallisella. Voit tarkistaa sen, kun päivität koodin hakemalla
kerran hae ja näe; koodi se ei muutu. Sitten yhdistät ... Näet muutetun koodin.
|
git fetch vetää koodin etäpalvelimelta paikallisen arkiston seurantahaaroihin. Jos kauko-ohjaimesi on nimetty alkuperä (oletus), nämä haarat ovat alkuperässä / esimerkiksi alkuperä / pääkäyttäjä, alkuperä / omahaara-123 jne. Nämä eivät ole nykyisiä haarojasi, vaan ne ovat paikallisia kopioita palvelimen haaroista .
git pull tekee git-haun, mutta yhdistää sitten myös seurantahaaran koodin nykyiseenkyseisen sivuliikkeen paikallinen versio. Jos et ole vielä valmis muutoksiin, hae ensin ensin.
|
git fetch noutaa etähaarat, jotta voit git diff tai git yhdistää ne nykyiseen haaraan. git pull suorittaa haun nykyisen haaran seuraamalle kauko-ohjaimelle ja yhdistää tuloksen. Voit käyttää git-noutoa nähdäksesi, onko etähaarassa päivityksiä yhdistämättä niitä paikalliseen haaraan.
|
Git Fetch
Lataat muutokset paikalliseen haaraan alkuperästä hakemiseen. Fetch pyytää etärepoa kaikista muista tekemistäsi tekemisistä, mutta sinulla ei ole paikallista repoasi. Fetch lataa nämä komennot ja lisää ne paikalliseen arkistoon.
Yhdistä
Voit soveltaa haun kautta ladattuja muutoksia yhdistämiskomennolla. Yhdistäminen ottaa hakemuksesta haetut tehtävät ja yrittää lisätä ne paikalliseen haarakonttoriin. Yhdistäminen säilyttää paikallisten muutosten sitoutumishistorian niin, että kun jaat haarasi pushilla, Git tietää, miten muut voivat yhdistää muutokset.
Git Pull
Nouto ja yhdistäminen suoritetaan yhdessä niin usein, että luotiin komento, joka yhdistää nämä kaksi, vedä. Pull tekee haun ja sitten yhdistämisen lisätäksesi ladatut sitoumukset paikalliseen haaraan.
|
Yksinkertaisesti sanottuna, jos aiot hypätä lentokoneeseen ilman Internet-yhteyttä ... ennen lähtöä voit vain tehdä haun alkuperän . Se noutaa kaikki muutokset tietokoneellesi, mutta pitää sen erillään paikallisesta kehitys- / työtilasta.
Lentokoneessa voit tehdä muutoksia paikalliseen työtilaan ja yhdistää sen sitten hakemallesi ja ratkaista mahdolliset yhdistämisristiriidat ilman Internet-yhteyttä. Ja ellei joku olisi tehnyt uusia muutoksia etätietovarastoon, saavuttaessasi määränpäähän saisit push-aloituksen  ja menisit saamaan kahvia.
Tästä mahtavasta Atlassian-opetusohjelmasta:
Git-noutokomento lataa sitoumukset, tiedostot ja viitteet a: sta
etätietovarasto paikalliseen arkistoon.
Nouto on mitä teet, kun haluat nähdä, mitä kaikilla muilla on
työskennellyt. Se on samanlainen kuin SVN-päivitys, koska sen avulla voit nähdä
kuinka keskeinen historia on edennyt, mutta se ei pakota sinua
sulauta muutokset tosiasiallisesti arkistoon. Git-isolaatit
haettu sisältö olemassa olevasta paikallisesta sisällöstä, sillä on ehdottomasti
ei vaikutusta paikalliseen kehitystyöhön. Haettu sisältö on tarkistettava erikseen git checkout -komennolla. Tämä tekee
haetaan turvallinen tapa tarkistaa sitoumukset ennen niiden integrointia
paikalliseen arkistoon.
Kun lataat sisältöä etätietovarastosta, tehtävän suorittamiseen on käytettävissä git pull- ja git fetch -komennot. Voit harkita
git noutaa kahden komennon 'turvallisen' version. Se ladataan
etäsisältö, mutta ei päivitä paikallisen arkiston toimintatilaa,
jättää nykyinen työsi koskemattomaksi. git pull on aggressiivisempi
Vaihtoehtoisesti se lataa etäsisällön aktiiviselle paikalliselle
haara ja suorita git merge välittömästi yhdistämissitoumuksen luomiseksi
uutta etsisisältöä varten. Jos odottavia muutoksia on käynnissä
tämä aiheuttaa konflikteja ja käynnistää yhdistämisen konfliktien ratkaisun
virtaus.
Git-vedolla:
Et saa mitään eristystä.
Sitä ei tarvitse erikseen tarkistaa. Koska se implisiittisesti yhdistää gitin.
Yhdistämisvaihe vaikuttaa paikalliseen kehitykseesi ja voi aiheuttaa ristiriitoja
Se ei periaatteessa ole turvallista. Se on aggressiivista.
Toisin kuin git-nouto, missä se vaikuttaa vain .git / refs / kaukosäätimiin, git pull vaikuttaa sekä .git / refs / kaukosäätimiin että .git / refs / heads /
Hmmm ... joten jos en päivitä työkopiota git-haulla, niin missä teen muutoksia? Mihin Git hakee uudet sitoumukset?
Suuri kysymys. Se asettaa sen jonnekin eristetyksi työkopiosta. Mutta jälleen missä? Otetaan selvää.
Tee projektihakemistossasi (ts. Missä teet git-komennot):
Ls. Tämä näyttää tiedostot ja hakemistot. Ei mitään hienoa, tiedän.
Tee nyt ls -a. Tämä näyttää pistetiedostot eli tiedostot, jotka alkavat. Sitten voit nähdä hakemiston nimeltä .git.
Tee cd .git. Tämä muuttaa tietysti hakemistosi.
Nyt tulee hauska osa; tee. Näet luettelon hakemistoista. Etsimme viitteitä. Tee cd-viitteitä.
On mielenkiintoista nähdä, mikä on kaikkien hakemistojen sisällä, mutta keskitymme kahteen niistä. päät ja kaukosäätimet. Käytä cd tarkistaa myös niiden sisällä.
Kaikki tekemäsi git-päivitykset päivittävät /.git/refs/remotes -hakemiston kohteet. Se ei päivitä mitään hakemistossa /.git/refs/heads.
Mikä tahansa git-vedos tekee ensin git-haun, päivittää kohteet /.git/refs/remotes -hakemistossa, sulautuu sitten paikalliseen ja vaihtaa sitten pään hakemiston /.git/refs/heads sisällä.
Erittäin hyvä asiaan liittyvä vastaus löytyy myös kohdasta Missä 'git hakee' itsensä ?.
Etsi myös "Slash-merkintää" Git-haaran nimeämiskäytäntöjen postista. Se auttaa sinua ymmärtämään paremmin, miten Git sijoittaa asiateri hakemistoja.
Nähdäksesi todellisen eron
Tee:
git-haun alkuperämestari
git kassan päällikkö
Jos kaukosäädin päivitettiin, saat seuraavanlaisen viestin:
Haarasi on alkuperäisen / päällikön takana kahdella sitoutumisella, ja se voidaan siirtää eteenpäin.
(käytä "git pull" päivittääksesi paikallisen haarasi)
Jos et hakenut ja vain teit git checkout -mestarin, paikallinen git ei tietäisi, että on lisätty 2 tekemistä. Ja se vain sanoisi:
Jo päällä 'master'
Haarasi on ajan tasalla alkuperän / päällikön kanssa.
Mutta se on vanhentunutta ja virheellistä. Se johtuu siitä, että git antaa sinulle palautetta vain sen perusteella, mitä se tietää. Se on unohdettu uusille sitoumuksille, joita se ei ole vielä vetänyt ...
Onko mitään tapaa nähdä uusia muutoksia, jotka on tehty etäyhteydessä työskennellessäsi haaratoimistossa paikallisesti?
Jotkut IDE: t (esim. Xcode) ovat erittäin älykkäitä ja käyttävät git-haun tulosta ja voivat merkitä koodirivit, joita on muutettu nykyisen työhaarasi etähaarassa. Jos kyseistä viivaa ovat muuttaneet sekä paikalliset muutokset että etähaara, tämä viiva merkitään punaisella. Tämä ei ole yhdistämiskonflikti. Se on mahdollinen yhdistämiskonflikti. Se on headsup, jonka avulla voit ratkaista tulevan yhdistämiskonfliktin ennen kuin teet git-vedon etähaarasta.
Hauska vinkki:
Jos hait etähaaran, esim. teki:
git-nouto-ominaisuus / 123
Sitten tämä menisi kaukosäätimihakemistoon. Se ei ole vieläkään käytettävissä paikallishakemistossasi. Se kuitenkin yksinkertaistaa DWIM: n (tee mitä tarkoitan) kauko-ohjauksen tälle etähaaralle:
git-kassaominaisuus / 123
sinun ei enää tarvitse tehdä:
git checkout -b ominaisuus / 123 alkuperä / ominaisuus / 123
Lisätietoja tästä lue täältä
|
Ainoa ero git-vedon ja git-haun välillä on, että:
git pull vetää etähaarasta ja yhdistää sen.
git fetch noutaa vain etähaarasta, mutta se ei yhdisty
ts. git pull = git nouto + git sulautua ...
|
Git sallii kronologisesti vanhempien sitoumusten soveltamisen uudempien sitoumusten jälkeen.
Tämän vuoksi toimeksianto siirtää sitoumuksia arkistojen välillä jaetaan kahteen vaiheeseen:
Kopioimalla uudet komennot etähaarasta kopioidaan tämä etähaara paikallisen repon sisällä.
(repo repo-toimintoon) master @ remote >> remote / origin / master @ local
Uusien sitoumusten integrointi paikalliseen haaratoimistoon
(sisäinen repo-toiminto) kaukosäädin / lähtö / isäntä @ paikallinen >> isäntä @ paikallinen
Vaihe 2 voidaan suorittaa kahdella tavalla. Voit:
Haarukkaa paikallinen haara viimeisen yhteisen esi-isän jälkeen ja lisää uusia sitoumuksia rinnakkain sitoumusten kanssa, jotka ovat ainutlaatuisia paikalliselle arkistolle, viimeistelty yhdistämällä sitoutuminen, sulkemalla haarukka.
Lisää uudet sitoumukset viimeisen yhteisen esi-isän jälkeen ja käytä uudelleen paikallisen tietovaraston yksilöllisiä sitoumuksia.
Git-terminologiassa vaihe 1 on git-nouto, vaihe 2 on git-yhdistäminen tai git-uudelleentase
git pull on git-nouto ja git-sulautuminen
|
Git hakee uusimman version haaran kaukosäätimestä paikalliseen kahdella komennolla:
git nouto: Git saa uusimman version kaukosäätimestä paikalliseen, mutta se ei sulautu automaattisesti.

git-haun alkuperämestari
git log -p -mestari..alku / isäntä
git merge origin / master
Yllä olevat komennot tarkoittavat, että ladataan päähaaran uusin versio alkuperästä kauko-ohjaimesta alkuperäiseen päähaaraan. Ja sitten vertaa paikallista päähaaraa ja alkuperäistä päähaaraa. Yhdistä lopuksi.
git pull: Git saa uusimman version kaukosäätimestä ja sulautuu paikalliseen.

git pull -aloitusmestari
Yllä oleva komento vastaa git-noutoa ja git-yhdistämistä. Käytännössä git-haku voi olla turvallisempi, koska ennen yhdistämistä voimme nähdä muutokset ja päättää yhdistämisestä.
|
Mitä eroa on git pullilla ja git-haulla?
Tämän ymmärtämiseksi sinun on ensin ymmärrettävä, että paikallinen git ylläpitää paitsi paikallista arkistoa myös ylläpitää paikallista kopiota etätietovarastosta.
git fetch tuo paikallisen kopion etätietovarastosta ajan tasalle. Esimerkiksi, jos etätietovarastosi on GitHub - sinun kannattaa hakea kaikki etätietovarastoon tehdyt muutokset sen paikalliseen kopioon. Tämän avulla voit suorittaa esimerkiksi vertailun tai yhdistämisen.
git pull toisaalta tuo muutokset etätietovarastoon sinne, missä pidät omaa koodiasi. Tyypillisesti git pull tekee ensin git-haun tuodakseen paikallisen kopion etätietovarastosta ajan tasalle, ja sitten se yhdistää muutokset omaan koodivarastoon ja mahdollisesti työkopioon.
|
git pull == (git-nouto + git-yhdistäminen)
git-nouto ei muutu paikallisiin haaroihin.
Jos sinulla on jo paikallinen tietovarasto, jossa etäyhteys on määritetty halutulle projektille, voit napata kaikki haarat ja tunnisteet olemassa olevalle kaukosäätimelle git-haun avulla. ... Hae ei tee mitään muutoksia paikallisiin haaroihin, joten sinun on yhdistettävä etähaara haaroitettuun paikalliseen haaraan sisällyttämään uudet haun muutokset. githubista
|
Yksinkertainen graafinen esitys aloittelijoille,
tässä,
git vetää
noutaa koodinarkistosta ja perustaa uudelleen paikallisen kanssa ... git pull -ohjelmassa on mahdollista luoda uusia sitoumuksia.
mutta
git noutaa
noutaa koodin arkistosta, ja meidän on tehtävä se uudelleen manuaalisesti käyttämällä git-uudelleentallennusohjelmaa
esim. aion hakea palvelinpäälliköltä ja käynnistää sen uudelleen paikallisessa pääkäyttäjässä.
1) git-vetäminen (uudelleentasaus tapahtuu automaattisesti):
git pull -aloitusmestari
tässä alkuperä on kauko-repo-isäntäsi on haarasi
2) git-nouto (täytyy perustaa uudelleen manuaalisesti):
git-haun alkuperämestari
se hakee palvelimen muutokset alkuperästä. ja se on paikallissasi, kunnes perustat sen uudelleen itse. meidän on korjattava ristiriidat manuaalisesti tarkistamalla koodit.
git-uudelleentallennus / master
tämä palauttaa koodin paikalliseksi. ennen sitä varmista, että olet oikeassa haarassa.
|
Yritetään olla selkeä ja yksinkertainen.
Git pull -komento on oikeastaan ​​pikakuvake git-haulle, jota seuraa git-yhdistäminen tai git-uudelleenkäsky -komento kokoonpanostasi riippuen. Voit määrittää Git-tietovarastosi siten, että git pull on nouto, jota seuraa uudelleenkäynnistys.
|
Oikeastaan ​​Git ylläpitää kopiota omasta koodistasi ja
etätietovarastoon.
Komento git fetch tekee paikallisesta kopiosta ajan tasalla hakemalla tietoja etätietovarastosta. Tarvitsemme tämän siksi, että joku muu on saattanut tehdä joitain muutoksia koodiin ja haluat pitää itsesi ajan tasalla.
Komento git pull tuo muutokset etätietovarastoon sinne, missä pidät omaa koodiasi. Normaalisti git pull tekee tämän tekemällä ensin git-haun tuodakseen etätietovaraston paikallisen kopion ajan tasalle, ja sitten se yhdistää muutokset omaan koodivarastoon ja mahdollisesti työkopioon.
|
1
2
Seuraava
Erittäin aktiivinen kysymys. Ansaitse 10 mainetta vastaamiseksi tähän kysymykseen. Maineen vaatimus auttaa suojaamaan tätä kysymystä roskapostilta ja vastaamattomuudelta.
Eikö vastausta etsit? Selaa muita kysymyksiä, jotka on merkitty sanalla git version-control git-pull git-fetch tai kysy oma kysymyksesi.